import { Router } from 'express';
import { agentController } from '../controllers/agentController';
import { asyncHandler, validateRequest, rateLimit } from '../middleware/errorHandler';
import { fileService } from '../services/fileService';

const router = Router();

// 应用速率限制
router.use(rateLimit(200, 15 * 60 * 1000)); // 每15分钟最多200个请求

/**
 * @route GET /api/agents
 * @desc 获取所有智能体（支持分页和搜索）
 * @query page - 页码（可选，默认1）
 * @query limit - 每页数量（可选，默认10）
 * @query search - 搜索关键词（可选）
 * @query category - 分类筛选（可选）
 * @query sortBy - 排序字段（可选，默认createdAt）
 * @query sortOrder - 排序方向（可选，默认desc）
 */
router.get('/', asyncHandler(agentController.getAllAgents.bind(agentController)));

/**
 * @route GET /api/agents/stats
 * @desc 获取智能体统计信息
 */
router.get('/stats', asyncHandler(agentController.getStats.bind(agentController)));

/**
 * @route GET /api/agents/export
 * @desc 导出所有智能体数据
 * @query format - 导出格式（可选，默认json）
 */
router.get('/export', asyncHandler(agentController.exportData.bind(agentController)));

/**
 * @route POST /api/agents/import
 * @desc 导入智能体数据
 * @body agents - 智能体数组
 * @body options - 导入选项（可选）
 */
router.post('/import', 
  validateRequest(['agents']),
  asyncHandler(agentController.importData.bind(agentController))
);

/**
 * @route POST /api/agents/migrate
 * @desc 数据迁移
 */
router.post('/migrate', 
  asyncHandler(agentController.migrateData.bind(agentController))
);

/**
 * @route GET /api/agents/:id
 * @desc 根据ID获取单个智能体
 * @param id - 智能体ID
 */
router.get('/:id', 
  validateRequest(['id'], 'params'),
  asyncHandler(agentController.getAgentById.bind(agentController))
);

/**
 * @route POST /api/agents
 * @desc 创建新智能体
 * @body name - 智能体名称（必需）
 * @body author - 作者名称（必需）
 * @body version - 版本号（必需）
 * @body category - 分类（必需）
 * @body shareUrl - 分享链接（必需）
 * @body description - 智能体描述（可选）
 * @body tags - 标签数组（可选）
 * @body config - 配置对象（可选）
 * @body usage - 使用说明（可选）
 */
router.post('/', 
  validateRequest(['name', 'author', 'version', 'category', 'shareUrl']),
  asyncHandler(agentController.createAgent.bind(agentController))
);

/**
 * @route PUT /api/agents/:id
 * @desc 更新智能体
 * @param id - 智能体ID
 * @body 要更新的字段（部分更新）
 */
router.put('/:id', 
  validateRequest(['id'], 'params'),
  asyncHandler(agentController.updateAgent.bind(agentController))
);

/**
 * @route PATCH /api/agents/:id
 * @desc 部分更新智能体（与PUT相同，提供更语义化的选择）
 * @param id - 智能体ID
 * @body 要更新的字段
 */
router.patch('/:id', 
  validateRequest(['id'], 'params'),
  asyncHandler(agentController.updateAgent.bind(agentController))
);

/**
 * @route DELETE /api/agents/:id
 * @desc 删除智能体
 * @param id - 智能体ID
 */
router.delete('/:id', 
  validateRequest(['id'], 'params'),
  asyncHandler(agentController.deleteAgent.bind(agentController))
);

/**
 * @route POST /api/agents/:id/clone
 * @desc 克隆智能体
 * @param id - 智能体ID
 */
router.post('/:id/clone', 
  validateRequest(['id'], 'params'),
  asyncHandler(async (req, res) => {
    try {
      const { id } = req.params;
      const agent = await fileService.getAgentById(id);
      
      if (!agent) {
        res.status(404).json({ success: false, error: 'Agent not found' });
        return;
      }
      
      // 创建克隆数据
      const cloneData = {
        ...agent,
        name: `${agent.name} (Copy)`,
        createdAt: new Date().toISOString(),
        updatedAt: new Date().toISOString()
      };
      
      // 直接使用文件服务创建克隆
      const newAgent = await fileService.createAgent(cloneData);
      
      res.status(201).json({
        success: true,
        data: newAgent
      });
    } catch (error) {
      res.status(500).json({ success: false, error: 'Failed to clone agent' });
    }
  })
);

/**
 * @route GET /api/agents/:id/similar
 * @desc 获取相似智能体
 * @param id - 智能体ID
 * @query limit - 返回数量限制（可选，默认5）
 */
router.get('/:id/similar', 
  validateRequest(['id'], 'params'),
  asyncHandler(async (req, res) => {
    try {
      const { id } = req.params;
      const limit = parseInt(req.query.limit as string) || 5;
      
      // 直接使用文件服务获取数据
      const { fileService } = require('../services/fileService');
      const currentAgent = await fileService.getAgentById(id);
      
      if (!currentAgent) {
        res.status(404).json({ success: false, error: 'Agent not found' });
        return;
      }
      
      const allAgents = await fileService.getAllAgents({ page: 1, limit: 100 });
      
      // 计算相似度并排序
      const similarAgents = allAgents.data
        .filter((agent: any) => agent.id !== id)
        .map((agent: any) => {
          let score = 0;
          
          // 分类匹配
          if (agent.category === currentAgent.category) {
            score += 3;
          }
          
          // 标签匹配
          const currentTags = currentAgent.tags || [];
          const agentTags = agent.tags || [];
          const commonTags = currentTags.filter((tag: string) => agentTags.includes(tag));
          score += commonTags.length;
          
          return { ...agent, similarityScore: score };
        })
        .filter((agent: any) => agent.similarityScore > 0)
        .sort((a: any, b: any) => b.similarityScore - a.similarityScore)
        .slice(0, limit)
        .map(({ similarityScore, ...agent }: any) => agent);
      
      res.json({
        success: true,
        data: similarAgents,
        pagination: {
          total: similarAgents.length,
          page: 1,
          limit,
          totalPages: 1
        }
      });
    } catch (error) {
      res.json({ success: true, data: [] });
    }
  })
);

/**
 * @route GET /api/agents/categories/list
 * @desc 获取所有分类列表
 */
router.get('/categories/list', asyncHandler(async (req, res) => {
  try {
    // 直接使用文件服务获取数据
    const { fileService } = require('../services/fileService');
    const agents = await fileService.getAllAgents({ page: 1, limit: 1000 });
    
    // 统计分类
    const categoryStats = new Map<string, number>();
    
    agents.data.forEach((agent: any) => {
      const category = agent.category || 'Uncategorized';
      categoryStats.set(category, (categoryStats.get(category) || 0) + 1);
    });
    
    // 转换为数组并排序
    const categories = Array.from(categoryStats.entries())
      .map(([name, count]) => ({ name, count }))
      .sort((a, b) => b.count - a.count);
    
    res.json({
      success: true,
      data: categories
    });
  } catch (error) {
    res.json({ success: true, data: [] });
  }
}));

/**
 * @route GET /api/agents/tags/popular
 * @desc 获取热门标签
 * @query limit - 返回数量限制（可选，默认20）
 */
router.get('/tags/popular', asyncHandler(async (req, res) => {
  try {
    const limit = parseInt(req.query.limit as string) || 20;
    
    // 直接使用文件服务获取数据
    const { fileService } = require('../services/fileService');
    const agents = await fileService.getAllAgents({ page: 1, limit: 1000 });
    
    // 统计标签
    const tagStats = new Map<string, number>();
    
    agents.data.forEach((agent: any) => {
      const tags = agent.tags || [];
      tags.forEach((tag: string) => {
        tagStats.set(tag, (tagStats.get(tag) || 0) + 1);
      });
    });
    
    // 转换为数组并排序
    const popularTags = Array.from(tagStats.entries())
      .map(([name, count]) => ({ name, count }))
      .sort((a, b) => b.count - a.count)
      .slice(0, limit);
    
    res.json({
      success: true,
      data: popularTags
    });
  } catch (error) {
    res.json({ success: true, data: [] });
  }
}));

export default router;